home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / i8085 / i8085.c < prev    next >
C/C++ Source or Header  |  2000-05-18  |  48KB  |  1,693 lines
  1. /*****************************************************************************
  2.  *
  3.  *     i8085.c
  4.  *     Portable I8085A emulator V1.1
  5.  *
  6.  *     Copyright (c) 1999 Juergen Buchmueller, all rights reserved.
  7.  *     Partially based on information out of Z80Em by Marcel De Kogel
  8.  *
  9.  *     - This source code is released as freeware for non-commercial purposes.
  10.  *     - You are free to use and redistribute this code in modified or
  11.  *       unmodified form, provided you list me in the credits.
  12.  *     - If you modify this source code, you must add a notice to each modified
  13.  *       source file that it has been changed.  If you're a nice person, you
  14.  *       will clearly mark each change too.  :)
  15.  *     - If you wish to use this for commercial purposes, please contact me at
  16.  *       pullmoll@t-online.de
  17.  *     - The author of this copywritten work reserves the right to change the
  18.  *     terms of its usage and license at any time, including retroactively
  19.  *   - This entire notice must remain in the source code.
  20.  *
  21.  *****************************************************************************/
  22.  
  23. #define VERBOSE 0
  24.  
  25. #include "driver.h"
  26. #include "state.h"
  27. #include "osd_cpu.h"
  28. #include "mamedbg.h"
  29. #include "i8085.h"
  30. #include "i8085cpu.h"
  31. #include "i8085daa.h"
  32.  
  33. #if VERBOSE
  34. #include <stdio.h>
  35. #include "driver.h"
  36. #define LOG(x) logerror x
  37. #else
  38. #define LOG(x)
  39. #endif
  40.  
  41. /* Layout of the registers in the debugger */
  42. static UINT8 i8085_reg_layout[] = {
  43.     I8085_PC,I8085_SP,I8085_AF,I8085_BC,I8085_DE,I8085_HL, -1,
  44.     I8085_HALT,I8085_IM,I8085_IREQ,I8085_ISRV,I8085_VECTOR, -1,
  45.     I8085_TRAP_STATE,I8085_INTR_STATE,I8085_RST55_STATE,I8085_RST65_STATE,I8085_RST75_STATE,
  46.     0 };
  47.  
  48. /* Layout of the debugger windows x,y,w,h */
  49. static UINT8 i8085_win_layout[] = {
  50.     25, 0,55, 3,    /* register window (top, right rows) */
  51.      0, 0,24,22,    /* disassembler window (left colums) */
  52.     25, 4,55, 9,    /* memory #1 window (right, upper middle) */
  53.     25,14,55, 8,    /* memory #2 window (right, lower middle) */
  54.      0,23,80, 1,    /* command line window (bottom rows) */
  55. };
  56.  
  57.  
  58. typedef struct {
  59.     int     cputype;    /* 0 8080, 1 8085A */
  60.     PAIR    PC,SP,AF,BC,DE,HL,XX;
  61.     UINT8   HALT;
  62.     UINT8    IM;         /* interrupt mask */
  63.     UINT8    IREQ;        /* requested interrupts */
  64.     UINT8    ISRV;        /* serviced interrupt */
  65.     UINT32    INTR;        /* vector for INTR */
  66.     UINT32    IRQ2;        /* scheduled interrupt address */
  67.     UINT32    IRQ1;        /* executed interrupt address */
  68.     INT8    nmi_state;
  69.     INT8    irq_state[4];
  70.     INT8    filler; /* align on dword boundary */
  71.     int     (*irq_callback)(int);
  72.     void    (*sod_callback)(int state);
  73. }   i8085_Regs;
  74.  
  75. int i8085_ICount = 0;
  76.  
  77. static i8085_Regs I;
  78. static UINT8 ZS[256];
  79. static UINT8 ZSP[256];
  80.  
  81. static UINT8 ROP(void)
  82. {
  83.     return cpu_readop(I.PC.w.l++);
  84. }
  85.  
  86. static UINT8 ARG(void)
  87. {
  88.     return cpu_readop_arg(I.PC.w.l++);
  89. }
  90.  
  91. static UINT16 ARG16(void)
  92. {
  93.     UINT16 w;
  94.     w  = cpu_readop_arg(I.PC.d);
  95.     I.PC.w.l++;
  96.     w += cpu_readop_arg(I.PC.d) << 8;
  97.     I.PC.w.l++;
  98.     return w;
  99. }
  100.  
  101. static UINT8 RM(UINT32 a)
  102. {
  103.     return cpu_readmem16(a);
  104. }
  105.  
  106. static void WM(UINT32 a, UINT8 v)
  107. {
  108.     cpu_writemem16(a, v);
  109. }
  110.  
  111. static  void illegal(void)
  112. {
  113. #if VERBOSE
  114.     UINT16 pc = I.PC.w.l - 1;
  115.     LOG(("i8085 illegal instruction %04X $%02X\n", pc, cpu_readop(pc)));
  116. #endif
  117. }
  118.  
  119. INLINE void execute_one(int opcode)
  120. {
  121.     switch (opcode)
  122.     {
  123.         case 0x00: i8085_ICount -= 4;    /* NOP    */
  124.             /* no op */
  125.             break;
  126.         case 0x01: i8085_ICount -= 10;    /* LXI    B,nnnn */
  127.             I.BC.w.l = ARG16();
  128.             break;
  129.         case 0x02: i8085_ICount -= 7;    /* STAX B */
  130.             WM(I.BC.d, I.AF.b.h);
  131.             break;
  132.         case 0x03: i8085_ICount -= 6;    /* INX    B */
  133.             I.BC.w.l++;
  134.             break;
  135.         case 0x04: i8085_ICount -= 4;    /* INR    B */
  136.             M_INR(I.BC.b.h);
  137.             break;
  138.         case 0x05: i8085_ICount -= 4;    /* DCR    B */
  139.             M_DCR(I.BC.b.h);
  140.             break;
  141.         case 0x06: i8085_ICount -= 7;    /* MVI    B,nn */
  142.             M_MVI(I.BC.b.h);
  143.             break;
  144.         case 0x07: i8085_ICount -= 4;    /* RLC    */
  145.             M_RLC;
  146.             break;
  147.  
  148.         case 0x08: i8085_ICount -= 4;    /* ???? */
  149.             illegal();
  150.             break;
  151.         case 0x09: i8085_ICount -= 11;    /* DAD    B */
  152.             M_DAD(BC);
  153.             break;
  154.         case 0x0a: i8085_ICount -= 7;    /* LDAX B */
  155.             I.AF.b.h = RM(I.BC.d);
  156.             break;
  157.         case 0x0b: i8085_ICount -= 6;    /* DCX    B */
  158.             I.BC.w.l--;
  159.             break;
  160.         case 0x0c: i8085_ICount -= 4;    /* INR    C */
  161.             M_INR(I.BC.b.l);
  162.             break;
  163.         case 0x0d: i8085_ICount -= 4;    /* DCR    C */
  164.             M_DCR(I.BC.b.l);
  165.             break;
  166.         case 0x0e: i8085_ICount -= 7;    /* MVI    C,nn */
  167.             M_MVI(I.BC.b.l);
  168.             break;
  169.         case 0x0f: i8085_ICount -= 4;    /* RRC    */
  170.             M_RRC;
  171.             break;
  172.  
  173.         case 0x10: i8085_ICount -= 8;    /* ????  */
  174.             illegal();
  175.             break;
  176.         case 0x11: i8085_ICount -= 10;    /* LXI    D,nnnn */
  177.             I.DE.w.l = ARG16();
  178.             break;
  179.         case 0x12: i8085_ICount -= 7;    /* STAX D */
  180.             WM(I.DE.d, I.AF.b.h);
  181.             break;
  182.         case 0x13: i8085_ICount -= 6;    /* INX    D */
  183.             I.DE.w.l++;
  184.             break;
  185.         case 0x14: i8085_ICount -= 4;    /* INR    D */
  186.             M_INR(I.DE.b.h);
  187.             break;
  188.         case 0x15: i8085_ICount -= 4;    /* DCR    D */
  189.             M_DCR(I.DE.b.h);
  190.             break;
  191.         case 0x16: i8085_ICount -= 7;    /* MVI    D,nn */
  192.             M_MVI(I.DE.b.h);
  193.             break;
  194.         case 0x17: i8085_ICount -= 4;    /* RAL    */
  195.             M_RAL;
  196.             break;
  197.  
  198.         case 0x18: i8085_ICount -= 7;    /* ????? */
  199.             illegal();
  200.             break;
  201.         case 0x19: i8085_ICount -= 11;    /* DAD    D */
  202.             M_DAD(DE);
  203.             break;
  204.         case 0x1a: i8085_ICount -= 7;    /* LDAX D */
  205.             I.AF.b.h = RM(I.DE.d);
  206.             break;
  207.         case 0x1b: i8085_ICount -= 6;    /* DCX    D */
  208.             I.DE.w.l--;
  209.             break;
  210.         case 0x1c: i8085_ICount -= 4;    /* INR    E */
  211.             M_INR(I.DE.b.l);
  212.             break;
  213.         case 0x1d: i8085_ICount -= 4;    /* DCR    E */
  214.             M_DCR(I.DE.b.l);
  215.             break;
  216.         case 0x1e: i8085_ICount -= 7;    /* MVI    E,nn */
  217.             M_MVI(I.DE.b.l);
  218.             break;
  219.         case 0x1f: i8085_ICount -= 4;    /* RAR    */
  220.             M_RAR;
  221.             break;
  222.  
  223.         case 0x20:
  224.             if( I.cputype )
  225.             {
  226.                 i8085_ICount -= 7;        /* RIM    */
  227.                 I.AF.b.h = I.IM;
  228.             }
  229.             else
  230.             {
  231.                 i8085_ICount -= 7;        /* ???    */
  232.             }
  233.             break;
  234.         case 0x21: i8085_ICount -= 10;    /* LXI    H,nnnn */
  235.             I.HL.w.l = ARG16();
  236.             break;
  237.         case 0x22: i8085_ICount -= 16;    /* SHLD nnnn */
  238.             I.XX.w.l = ARG16();
  239.             WM(I.XX.d, I.HL.b.l);
  240.             I.XX.w.l++;
  241.             WM(I.XX.d, I.HL.b.h);
  242.             break;
  243.         case 0x23: i8085_ICount -= 6;    /* INX    H */
  244.             I.HL.w.l++;
  245.             break;
  246.         case 0x24: i8085_ICount -= 4;    /* INR    H */
  247.             M_INR(I.HL.b.h);
  248.             break;
  249.         case 0x25: i8085_ICount -= 4;    /* DCR    H */
  250.             M_DCR(I.HL.b.h);
  251.             break;
  252.         case 0x26: i8085_ICount -= 7;    /* MVI    H,nn */
  253.             M_MVI(I.HL.b.h);
  254.             break;
  255.         case 0x27: i8085_ICount -= 4;    /* DAA    */
  256.             I.XX.d = I.AF.b.h;
  257.             if (I.AF.b.l & CF) I.XX.d |= 0x100;
  258.             if (I.AF.b.l & HF) I.XX.d |= 0x200;
  259.             if (I.AF.b.l & NF) I.XX.d |= 0x400;
  260.             I.AF.w.l = DAA[I.XX.d];
  261.             break;
  262.  
  263.         case 0x28: i8085_ICount -= 7;    /* ???? */
  264.             illegal();
  265.             break;
  266.         case 0x29: i8085_ICount -= 11;    /* DAD    H */
  267.             M_DAD(HL);
  268.             break;
  269.         case 0x2a: i8085_ICount -= 16;    /* LHLD nnnn */
  270.             I.XX.d = ARG16();
  271.             I.HL.b.l = RM(I.XX.d);
  272.             I.XX.w.l++;
  273.             I.HL.b.h = RM(I.XX.d);
  274.             break;
  275.         case 0x2b: i8085_ICount -= 6;    /* DCX    H */
  276.             I.HL.w.l--;
  277.             break;
  278.         case 0x2c: i8085_ICount -= 4;    /* INR    L */
  279.             M_INR(I.HL.b.l);
  280.             break;
  281.         case 0x2d: i8085_ICount -= 4;    /* DCR    L */
  282.             M_DCR(I.HL.b.l);
  283.             break;
  284.         case 0x2e: i8085_ICount -= 7;    /* MVI    L,nn */
  285.             M_MVI(I.HL.b.l);
  286.             break;
  287.         case 0x2f: i8085_ICount -= 4;    /* CMA    */
  288.             I.AF.b.h ^= 0xff;
  289.             I.AF.b.l |= HF + NF;
  290.             break;
  291.  
  292.         case 0x30:
  293.             if( I.cputype )
  294.             {
  295.                 i8085_ICount -= 7;        /* SIM    */
  296.                 if ((I.IM ^ I.AF.b.h) & 0x80)
  297.                     if (I.sod_callback) (*I.sod_callback)(I.AF.b.h >> 7);
  298.                 I.IM &= (IM_SID + IM_IEN + IM_TRAP);
  299.                 I.IM |= (I.AF.b.h & ~(IM_SID + IM_SOD + IM_IEN + IM_TRAP));
  300.                 if (I.AF.b.h & 0x80) I.IM |= IM_SOD;
  301.             }
  302.             else
  303.             {
  304.                 i8085_ICount -= 4;        /* ???    */
  305.             }
  306.             break;
  307.         case 0x31: i8085_ICount -= 10;    /* LXI SP,nnnn */
  308.             I.SP.w.l = ARG16();
  309.             break;
  310.         case 0x32: i8085_ICount -= 13;    /* STAX nnnn */
  311.             I.XX.d = ARG16();
  312.             WM(I.XX.d, I.AF.b.h);
  313.             break;
  314.         case 0x33: i8085_ICount -= 6;    /* INX    SP */
  315.             I.SP.w.l++;
  316.             break;
  317.         case 0x34: i8085_ICount -= 11;    /* INR    M */
  318.             I.XX.b.l = RM(I.HL.d);
  319.             M_INR(I.XX.b.l);
  320.             WM(I.HL.d, I.XX.b.l);
  321.             break;
  322.         case 0x35: i8085_ICount -= 11;    /* DCR    M */
  323.             I.XX.b.l = RM(I.HL.d);
  324.             M_DCR(I.XX.b.l);
  325.             WM(I.HL.d, I.XX.b.l);
  326.             break;
  327.         case 0x36: i8085_ICount -= 10;    /* MVI    M,nn */
  328.             I.XX.b.l = ARG();
  329.             WM(I.HL.d, I.XX.b.l);
  330.             break;
  331.         case 0x37: i8085_ICount -= 4;    /* STC    */
  332.             I.AF.b.l = (I.AF.b.l & ~(HF + NF)) | CF;
  333.             break;
  334.  
  335.         case 0x38: i8085_ICount -= 7;    /* ???? */
  336.             illegal();
  337.             break;
  338.         case 0x39: i8085_ICount -= 11;    /* DAD SP */
  339.             M_DAD(SP);
  340.             break;
  341.         case 0x3a: i8085_ICount -= 13;    /* LDAX nnnn */
  342.             I.XX.d = ARG16();
  343.             I.AF.b.h = RM(I.XX.d);
  344.             break;
  345.         case 0x3b: i8085_ICount -= 6;    /* DCX    SP */
  346.             I.SP.w.l--;
  347.             break;
  348.         case 0x3c: i8085_ICount -= 4;    /* INR    A */
  349.             M_INR(I.AF.b.h);
  350.             break;
  351.         case 0x3d: i8085_ICount -= 4;    /* DCR    A */
  352.             M_DCR(I.AF.b.h);
  353.             break;
  354.         case 0x3e: i8085_ICount -= 7;    /* MVI    A,nn */
  355.             M_MVI(I.AF.b.h);
  356.             break;
  357.         case 0x3f: i8085_ICount -= 4;    /* CMF    */
  358.             I.AF.b.l = ((I.AF.b.l & ~(HF + NF)) |
  359.                        ((I.AF.b.l & CF) << 4)) ^ CF;
  360.             break;
  361.  
  362.         case 0x40: i8085_ICount -= 4;    /* MOV    B,B */
  363.             /* no op */
  364.             break;
  365.         case 0x41: i8085_ICount -= 4;    /* MOV    B,C */
  366.             I.BC.b.h = I.BC.b.l;
  367.             break;
  368.         case 0x42: i8085_ICount -= 4;    /* MOV    B,D */
  369.             I.BC.b.h = I.DE.b.h;
  370.             break;
  371.         case 0x43: i8085_ICount -= 4;    /* MOV    B,E */
  372.             I.BC.b.h = I.DE.b.l;
  373.             break;
  374.         case 0x44: i8085_ICount -= 4;    /* MOV    B,H */
  375.             I.BC.b.h = I.HL.b.h;
  376.             break;
  377.         case 0x45: i8085_ICount -= 4;    /* MOV    B,L */
  378.             I.BC.b.h = I.HL.b.l;
  379.             break;
  380.         case 0x46: i8085_ICount -= 7;    /* MOV    B,M */
  381.             I.BC.b.h = RM(I.HL.d);
  382.             break;
  383.         case 0x47: i8085_ICount -= 4;    /* MOV    B,A */
  384.             I.BC.b.h = I.AF.b.h;
  385.             break;
  386.  
  387.          case 0x48: i8085_ICount -= 4;     /* MOV  C,B */
  388.             I.BC.b.l = I.BC.b.h;
  389.             break;
  390.         case 0x49: i8085_ICount -= 4;    /* MOV    C,C */
  391.             /* no op */
  392.             break;
  393.         case 0x4a: i8085_ICount -= 4;    /* MOV    C,D */
  394.             I.BC.b.l = I.DE.b.h;
  395.             break;
  396.         case 0x4b: i8085_ICount -= 4;    /* MOV    C,E */
  397.             I.BC.b.l = I.DE.b.l;
  398.             break;
  399.         case 0x4c: i8085_ICount -= 4;    /* MOV    C,H */
  400.             I.BC.b.l = I.HL.b.h;
  401.             break;
  402.         case 0x4d: i8085_ICount -= 4;    /* MOV    C,L */
  403.             I.BC.b.l = I.HL.b.l;
  404.             break;
  405.         case 0x4e: i8085_ICount -= 7;    /* MOV    C,M */
  406.             I.BC.b.l = RM(I.HL.d);
  407.             break;
  408.         case 0x4f: i8085_ICount -= 4;    /* MOV    C,A */
  409.             I.BC.b.l = I.AF.b.h;
  410.             break;
  411.  
  412.         case 0x50: i8085_ICount -= 4;    /* MOV    D,B */
  413.             I.DE.b.h = I.BC.b.h;
  414.             break;
  415.         case 0x51: i8085_ICount -= 4;    /* MOV    D,C */
  416.             I.DE.b.h = I.BC.b.l;
  417.             break;
  418.         case 0x52: i8085_ICount -= 4;    /* MOV    D,D */
  419.             /* no op */
  420.             break;
  421.         case 0x53: i8085_ICount -= 4;    /* MOV    D,E */
  422.             I.DE.b.h = I.DE.b.l;
  423.             break;
  424.         case 0x54: i8085_ICount -= 4;    /* MOV    D,H */
  425.             I.DE.b.h = I.HL.b.h;
  426.             break;
  427.         case 0x55: i8085_ICount -= 4;    /* MOV    D,L */
  428.             I.DE.b.h = I.HL.b.l;
  429.             break;
  430.         case 0x56: i8085_ICount -= 7;    /* MOV    D,M */
  431.             I.DE.b.h = RM(I.HL.d);
  432.             break;
  433.         case 0x57: i8085_ICount -= 4;    /* MOV    D,A */
  434.             I.DE.b.h = I.AF.b.h;
  435.             break;
  436.  
  437.         case 0x58: i8085_ICount -= 4;    /* MOV    E,B */
  438.             I.DE.b.l = I.BC.b.h;
  439.             break;
  440.         case 0x59: i8085_ICount -= 4;    /* MOV    E,C */
  441.             I.DE.b.l = I.BC.b.l;
  442.             break;
  443.         case 0x5a: i8085_ICount -= 4;    /* MOV    E,D */
  444.             I.DE.b.l = I.DE.b.h;
  445.             break;
  446.         case 0x5b: i8085_ICount -= 4;    /* MOV    E,E */
  447.             /* no op */
  448.             break;
  449.         case 0x5c: i8085_ICount -= 4;    /* MOV    E,H */
  450.             I.DE.b.l = I.HL.b.h;
  451.             break;
  452.         case 0x5d: i8085_ICount -= 4;    /* MOV    E,L */
  453.             I.DE.b.l = I.HL.b.l;
  454.             break;
  455.         case 0x5e: i8085_ICount -= 7;    /* MOV    E,M */
  456.             I.DE.b.l = RM(I.HL.d);
  457.             break;
  458.         case 0x5f: i8085_ICount -= 4;    /* MOV    E,A */
  459.             I.DE.b.l = I.AF.b.h;
  460.             break;
  461.  
  462.          case 0x60: i8085_ICount -= 4;     /* MOV  H,B */
  463.             I.HL.b.h = I.BC.b.h;
  464.             break;
  465.         case 0x61: i8085_ICount -= 4;    /* MOV    H,C */
  466.             I.HL.b.h = I.BC.b.l;
  467.             break;
  468.         case 0x62: i8085_ICount -= 4;    /* MOV    H,D */
  469.             I.HL.b.h = I.DE.b.h;
  470.             break;
  471.         case 0x63: i8085_ICount -= 4;    /* MOV    H,E */
  472.             I.HL.b.h = I.DE.b.l;
  473.             break;
  474.         case 0x64: i8085_ICount -= 4;    /* MOV    H,H */
  475.             /* no op */
  476.             break;
  477.         case 0x65: i8085_ICount -= 4;    /* MOV    H,L */
  478.             I.HL.b.h = I.HL.b.l;
  479.             break;
  480.         case 0x66: i8085_ICount -= 7;    /* MOV    H,M */
  481.             I.HL.b.h = RM(I.HL.d);
  482.             break;
  483.         case 0x67: i8085_ICount -= 4;    /* MOV    H,A */
  484.             I.HL.b.h = I.AF.b.h;
  485.             break;
  486.  
  487.         case 0x68: i8085_ICount -= 4;    /* MOV    L,B */
  488.             I.HL.b.l = I.BC.b.h;
  489.             break;
  490.         case 0x69: i8085_ICount -= 4;    /* MOV    L,C */
  491.             I.HL.b.l = I.BC.b.l;
  492.             break;
  493.         case 0x6a: i8085_ICount -= 4;    /* MOV    L,D */
  494.             I.HL.b.l = I.DE.b.h;
  495.             break;
  496.         case 0x6b: i8085_ICount -= 4;    /* MOV    L,E */
  497.             I.HL.b.l = I.DE.b.l;
  498.             break;
  499.         case 0x6c: i8085_ICount -= 4;    /* MOV    L,H */
  500.             I.HL.b.l = I.HL.b.h;
  501.             break;
  502.         case 0x6d: i8085_ICount -= 4;    /* MOV    L,L */
  503.             /* no op */
  504.             break;
  505.         case 0x6e: i8085_ICount -= 7;    /* MOV    L,M */
  506.             I.HL.b.l = RM(I.HL.d);
  507.             break;
  508.         case 0x6f: i8085_ICount -= 4;    /* MOV    L,A */
  509.             I.HL.b.l = I.AF.b.h;
  510.             break;
  511.  
  512.         case 0x70: i8085_ICount -= 7;    /* MOV    M,B */
  513.             WM(I.HL.d, I.BC.b.h);
  514.             break;
  515.         case 0x71: i8085_ICount -= 7;    /* MOV    M,C */
  516.             WM(I.HL.d, I.BC.b.l);
  517.             break;
  518.         case 0x72: i8085_ICount -= 7;    /* MOV    M,D */
  519.             WM(I.HL.d, I.DE.b.h);
  520.             break;
  521.         case 0x73: i8085_ICount -= 7;    /* MOV    M,E */
  522.             WM(I.HL.d, I.DE.b.l);
  523.             break;
  524.         case 0x74: i8085_ICount -= 7;    /* MOV    M,H */
  525.             WM(I.HL.d, I.HL.b.h);
  526.             break;
  527.         case 0x75: i8085_ICount -= 7;    /* MOV    M,L */
  528.             WM(I.HL.d, I.HL.b.l);
  529.             break;
  530.         case 0x76: i8085_ICount -= 4;    /* HALT */
  531.             I.PC.w.l--;
  532.             I.HALT = 1;
  533.             if (i8085_ICount > 0) i8085_ICount = 0;
  534.             break;
  535.         case 0x77: i8085_ICount -= 7;    /* MOV    M,A */
  536.             WM(I.HL.d, I.AF.b.h);
  537.             break;
  538.  
  539.         case 0x78: i8085_ICount -= 4;    /* MOV    A,B */
  540.             I.AF.b.h = I.BC.b.h;
  541.             break;
  542.         case 0x79: i8085_ICount -= 4;    /* MOV    A,C */
  543.             I.AF.b.h = I.BC.b.l;
  544.             break;
  545.         case 0x7a: i8085_ICount -= 4;    /* MOV    A,D */
  546.             I.AF.b.h = I.DE.b.h;
  547.             break;
  548.         case 0x7b: i8085_ICount -= 4;    /* MOV    A,E */
  549.             I.AF.b.h = I.DE.b.l;
  550.             break;
  551.         case 0x7c: i8085_ICount -= 4;    /* MOV    A,H */
  552.             I.AF.b.h = I.HL.b.h;
  553.             break;
  554.         case 0x7d: i8085_ICount -= 4;    /* MOV    A,L */
  555.             I.AF.b.h = I.HL.b.l;
  556.             break;
  557.         case 0x7e: i8085_ICount -= 7;    /* MOV    A,M */
  558.             I.AF.b.h = RM(I.HL.d);
  559.             break;
  560.         case 0x7f: i8085_ICount -= 4;    /* MOV    A,A */
  561.             /* no op */
  562.             break;
  563.  
  564.         case 0x80: i8085_ICount -= 4;    /* ADD    B */
  565.             M_ADD(I.BC.b.h);
  566.             break;
  567.         case 0x81: i8085_ICount -= 4;    /* ADD    C */
  568.             M_ADD(I.BC.b.l);
  569.             break;
  570.         case 0x82: i8085_ICount -= 4;    /* ADD    D */
  571.             M_ADD(I.DE.b.h);
  572.             break;
  573.         case 0x83: i8085_ICount -= 4;    /* ADD    E */
  574.             M_ADD(I.DE.b.l);
  575.             break;
  576.         case 0x84: i8085_ICount -= 4;    /* ADD    H */
  577.             M_ADD(I.HL.b.h);
  578.             break;
  579.         case 0x85: i8085_ICount -= 4;    /* ADD    L */
  580.             M_ADD(I.HL.b.l);
  581.             break;
  582.         case 0x86: i8085_ICount -= 7;    /* ADD    M */
  583.             M_ADD(RM(I.HL.d));
  584.             break;
  585.         case 0x87: i8085_ICount -= 4;    /* ADD    A */
  586.             M_ADD(I.AF.b.h);
  587.             break;
  588.  
  589.         case 0x88: i8085_ICount -= 4;    /* ADC    B */
  590.             M_ADC(I.BC.b.h);
  591.             break;
  592.         case 0x89: i8085_ICount -= 4;    /* ADC    C */
  593.             M_ADC(I.BC.b.l);
  594.             break;
  595.         case 0x8a: i8085_ICount -= 4;    /* ADC    D */
  596.             M_ADC(I.DE.b.h);
  597.             break;
  598.         case 0x8b: i8085_ICount -= 4;    /* ADC    E */
  599.             M_ADC(I.DE.b.l);
  600.             break;
  601.         case 0x8c: i8085_ICount -= 4;    /* ADC    H */
  602.             M_ADC(I.HL.b.h);
  603.             break;
  604.         case 0x8d: i8085_ICount -= 4;    /* ADC    L */
  605.             M_ADC(I.HL.b.l);
  606.             break;
  607.         case 0x8e: i8085_ICount -= 7;    /* ADC    M */
  608.             M_ADC(RM(I.HL.d));
  609.             break;
  610.         case 0x8f: i8085_ICount -= 4;    /* ADC    A */
  611.             M_ADC(I.AF.b.h);
  612.             break;
  613.  
  614.         case 0x90: i8085_ICount -= 4;    /* SUB    B */
  615.             M_SUB(I.BC.b.h);
  616.             break;
  617.         case 0x91: i8085_ICount -= 4;    /* SUB    C */
  618.             M_SUB(I.BC.b.l);
  619.             break;
  620.         case 0x92: i8085_ICount -= 4;    /* SUB    D */
  621.             M_SUB(I.DE.b.h);
  622.             break;
  623.         case 0x93: i8085_ICount -= 4;    /* SUB    E */
  624.             M_SUB(I.DE.b.l);
  625.             break;
  626.         case 0x94: i8085_ICount -= 4;    /* SUB    H */
  627.             M_SUB(I.HL.b.h);
  628.             break;
  629.         case 0x95: i8085_ICount -= 4;    /* SUB    L */
  630.             M_SUB(I.HL.b.l);
  631.             break;
  632.         case 0x96: i8085_ICount -= 7;    /* SUB    M */
  633.             M_SUB(RM(I.HL.d));
  634.             break;
  635.         case 0x97: i8085_ICount -= 4;    /* SUB    A */
  636.             M_SUB(I.AF.b.h);
  637.             break;
  638.  
  639.         case 0x98: i8085_ICount -= 4;    /* SBB    B */
  640.             M_SBB(I.BC.b.h);
  641.             break;
  642.         case 0x99: i8085_ICount -= 4;    /* SBB    C */
  643.             M_SBB(I.BC.b.l);
  644.             break;
  645.         case 0x9a: i8085_ICount -= 4;    /* SBB    D */
  646.             M_SBB(I.DE.b.h);
  647.             break;
  648.         case 0x9b: i8085_ICount -= 4;    /* SBB    E */
  649.             M_SBB(I.DE.b.l);
  650.             break;
  651.         case 0x9c: i8085_ICount -= 4;    /* SBB    H */
  652.             M_SBB(I.HL.b.h);
  653.             break;
  654.         case 0x9d: i8085_ICount -= 4;    /* SBB    L */
  655.             M_SBB(I.HL.b.l);
  656.             break;
  657.         case 0x9e: i8085_ICount -= 7;    /* SBB    M */
  658.             M_SBB(RM(I.HL.d));
  659.             break;
  660.         case 0x9f: i8085_ICount -= 4;    /* SBB    A */
  661.             M_SBB(I.AF.b.h);
  662.             break;
  663.  
  664.         case 0xa0: i8085_ICount -= 4;    /* ANA    B */
  665.             M_ANA(I.BC.b.h);
  666.             break;
  667.         case 0xa1: i8085_ICount -= 4;    /* ANA    C */
  668.             M_ANA(I.BC.b.l);
  669.             break;
  670.         case 0xa2: i8085_ICount -= 4;    /* ANA    D */
  671.             M_ANA(I.DE.b.h);
  672.             break;
  673.         case 0xa3: i8085_ICount -= 4;    /* ANA    E */
  674.             M_ANA(I.DE.b.l);
  675.             break;
  676.         case 0xa4: i8085_ICount -= 4;    /* ANA    H */
  677.             M_ANA(I.HL.b.h);
  678.             break;
  679.         case 0xa5: i8085_ICount -= 4;    /* ANA    L */
  680.             M_ANA(I.HL.b.l);
  681.             break;
  682.         case 0xa6: i8085_ICount -= 7;    /* ANA    M */
  683.             M_ANA(RM(I.HL.d));
  684.             break;
  685.         case 0xa7: i8085_ICount -= 4;    /* ANA    A */
  686.             M_ANA(I.AF.b.h);
  687.             break;
  688.  
  689.         case 0xa8: i8085_ICount -= 4;    /* XRA    B */
  690.             M_XRA(I.BC.b.h);
  691.             break;
  692.         case 0xa9: i8085_ICount -= 4;    /* XRA    C */
  693.             M_XRA(I.BC.b.l);
  694.             break;
  695.         case 0xaa: i8085_ICount -= 4;    /* XRA    D */
  696.             M_XRA(I.DE.b.h);
  697.             break;
  698.         case 0xab: i8085_ICount -= 4;    /* XRA    E */
  699.             M_XRA(I.DE.b.l);
  700.             break;
  701.         case 0xac: i8085_ICount -= 4;    /* XRA    H */
  702.             M_XRA(I.HL.b.h);
  703.             break;
  704.         case 0xad: i8085_ICount -= 4;    /* XRA    L */
  705.             M_XRA(I.HL.b.l);
  706.             break;
  707.         case 0xae: i8085_ICount -= 7;    /* XRA    M */
  708.             M_XRA(RM(I.HL.d));
  709.             break;
  710.         case 0xaf: i8085_ICount -= 4;    /* XRA    A */
  711.             M_XRA(I.AF.b.h);
  712.             break;
  713.  
  714.         case 0xb0: i8085_ICount -= 4;    /* ORA    B */
  715.             M_ORA(I.BC.b.h);
  716.             break;
  717.         case 0xb1: i8085_ICount -= 4;    /* ORA    C */
  718.             M_ORA(I.BC.b.l);
  719.             break;
  720.         case 0xb2: i8085_ICount -= 4;    /* ORA    D */
  721.             M_ORA(I.DE.b.h);
  722.             break;
  723.         case 0xb3: i8085_ICount -= 4;    /* ORA    E */
  724.             M_ORA(I.DE.b.l);
  725.             break;
  726.         case 0xb4: i8085_ICount -= 4;    /* ORA    H */
  727.             M_ORA(I.HL.b.h);
  728.             break;
  729.         case 0xb5: i8085_ICount -= 4;    /* ORA    L */
  730.             M_ORA(I.HL.b.l);
  731.             break;
  732.         case 0xb6: i8085_ICount -= 7;    /* ORA    M */
  733.             M_ORA(RM(I.HL.d));
  734.             break;
  735.         case 0xb7: i8085_ICount -= 4;    /* ORA    A */
  736.             M_ORA(I.AF.b.h);
  737.             break;
  738.  
  739.         case 0xb8: i8085_ICount -= 4;    /* CMP    B */
  740.             M_CMP(I.BC.b.h);
  741.             break;
  742.         case 0xb9: i8085_ICount -= 4;    /* CMP    C */
  743.             M_CMP(I.BC.b.l);
  744.             break;
  745.         case 0xba: i8085_ICount -= 4;    /* CMP    D */
  746.             M_CMP(I.DE.b.h);
  747.             break;
  748.         case 0xbb: i8085_ICount -= 4;    /* CMP    E */
  749.             M_CMP(I.DE.b.l);
  750.             break;
  751.         case 0xbc: i8085_ICount -= 4;    /* CMP    H */
  752.             M_CMP(I.HL.b.h);
  753.             break;
  754.         case 0xbd: i8085_ICount -= 4;    /* CMP    L */
  755.             M_CMP(I.HL.b.l);
  756.             break;
  757.         case 0xbe: i8085_ICount -= 7;    /* CMP    M */
  758.             M_CMP(RM(I.HL.d));
  759.             break;
  760.         case 0xbf: i8085_ICount -= 4;    /* CMP    A */
  761.             M_CMP(I.AF.b.h);
  762.             break;
  763.  
  764.         case 0xc0: i8085_ICount -= 5;    /* RNZ    */
  765.             M_RET( !(I.AF.b.l & ZF) );
  766.             break;
  767.         case 0xc1: i8085_ICount -= 10;    /* POP    B */
  768.             M_POP(BC);
  769.             break;
  770.         case 0xc2: i8085_ICount -= 10;    /* JNZ    nnnn */
  771.             M_JMP( !(I.AF.b.l & ZF) );
  772.             break;
  773.         case 0xc3: i8085_ICount -= 10;    /* JMP    nnnn */
  774.             M_JMP(1);
  775.             break;
  776.         case 0xc4: i8085_ICount -= 10;    /* CNZ    nnnn */
  777.             M_CALL( !(I.AF.b.l & ZF) );
  778.             break;
  779.         case 0xc5: i8085_ICount -= 11;    /* PUSH B */
  780.             M_PUSH(BC);
  781.             break;
  782.         case 0xc6: i8085_ICount -= 7;    /* ADI    nn */
  783.             I.XX.b.l = ARG();
  784.             M_ADD(I.XX.b.l);
  785.                 break;
  786.         case 0xc7: i8085_ICount -= 11;    /* RST    0 */
  787.             M_RST(0);
  788.             break;
  789.  
  790.         case 0xc8: i8085_ICount -= 5;    /* RZ    */
  791.             M_RET( I.AF.b.l & ZF );
  792.             break;
  793.         case 0xc9: i8085_ICount -= 4;    /* RET    */
  794.             M_RET(1);
  795.             break;
  796.         case 0xca: i8085_ICount -= 10;    /* JZ    nnnn */
  797.             M_JMP( I.AF.b.l & ZF );
  798.             break;
  799.         case 0xcb: i8085_ICount -= 4;    /* ???? */
  800.             illegal();
  801.             break;
  802.         case 0xcc: i8085_ICount -= 10;    /* CZ    nnnn */
  803.             M_CALL( I.AF.b.l & ZF );
  804.             break;
  805.         case 0xcd: i8085_ICount -= 10;    /* CALL nnnn */
  806.             M_CALL(1);
  807.             break;
  808.         case 0xce: i8085_ICount -= 7;    /* ACI    nn */
  809.             I.XX.b.l = ARG();
  810.             M_ADC(I.XX.b.l);
  811.             break;
  812.         case 0xcf: i8085_ICount -= 11;    /* RST    1 */
  813.             M_RST(1);
  814.             break;
  815.  
  816.         case 0xd0: i8085_ICount -= 5;    /* RNC    */
  817.             M_RET( !(I.AF.b.l & CF) );
  818.             break;
  819.         case 0xd1: i8085_ICount -= 10;    /* POP    D */
  820.             M_POP(DE);
  821.             break;
  822.         case 0xd2: i8085_ICount -= 10;    /* JNC    nnnn */
  823.             M_JMP( !(I.AF.b.l & CF) );
  824.             break;
  825.         case 0xd3: i8085_ICount -= 11;    /* OUT    nn */
  826.             M_OUT;
  827.             break;
  828.         case 0xd4: i8085_ICount -= 10;    /* CNC    nnnn */
  829.             M_CALL( !(I.AF.b.l & CF) );
  830.             break;
  831.         case 0xd5: i8085_ICount -= 11;    /* PUSH D */
  832.             M_PUSH(DE);
  833.             break;
  834.         case 0xd6: i8085_ICount -= 7;    /* SUI    nn */
  835.             I.XX.b.l = ARG();
  836.             M_SUB(I.XX.b.l);
  837.             break;
  838.         case 0xd7: i8085_ICount -= 11;    /* RST    2 */
  839.             M_RST(2);
  840.             break;
  841.  
  842.         case 0xd8: i8085_ICount -= 5;    /* RC    */
  843.             M_RET( I.AF.b.l & CF );
  844.             break;
  845.         case 0xd9: i8085_ICount -= 4;    /* ???? */
  846.             illegal();
  847.             break;
  848.         case 0xda: i8085_ICount -= 10;    /* JC    nnnn */
  849.             M_JMP( I.AF.b.l & CF );
  850.             break;
  851.         case 0xdb: i8085_ICount -= 11;    /* IN    nn */
  852.             M_IN;
  853.             break;
  854.         case 0xdc: i8085_ICount -= 10;    /* CC    nnnn */
  855.             M_CALL( I.AF.b.l & CF );
  856.             break;
  857.         case 0xdd: i8085_ICount -= 4;    /* ???? */
  858.             illegal();
  859.             break;
  860.         case 0xde: i8085_ICount -= 7;    /* SBI    nn */
  861.             I.XX.b.l = ARG();
  862.             M_SBB(I.XX.b.l);
  863.             break;
  864.         case 0xdf: i8085_ICount -= 11;    /* RST    3 */
  865.             M_RST(3);
  866.             break;
  867.  
  868.         case 0xe0: i8085_ICount -= 5;    /* RPE      */
  869.             M_RET( !(I.AF.b.l & VF) );
  870.             break;
  871.         case 0xe1: i8085_ICount -= 10;    /* POP    H */
  872.             M_POP(HL);
  873.             break;
  874.         case 0xe2: i8085_ICount -= 10;    /* JPE    nnnn */
  875.             M_JMP( !(I.AF.b.l & VF) );
  876.             break;
  877.         case 0xe3: i8085_ICount -= 19;    /* XTHL */
  878.             M_POP(XX);
  879.             M_PUSH(HL);
  880.             I.HL.d = I.XX.d;
  881.             break;
  882.         case 0xe4: i8085_ICount -= 10;    /* CPE    nnnn */
  883.             M_CALL( !(I.AF.b.l & VF) );
  884.             break;
  885.         case 0xe5: i8085_ICount -= 11;    /* PUSH H */
  886.             M_PUSH(HL);
  887.             break;
  888.         case 0xe6: i8085_ICount -= 7;    /* ANI    nn */
  889.             I.XX.b.l = ARG();
  890.             M_ANA(I.XX.b.l);
  891.             break;
  892.         case 0xe7: i8085_ICount -= 11;    /* RST    4 */
  893.             M_RST(4);
  894.             break;
  895.  
  896.         case 0xe8: i8085_ICount -= 5;    /* RPO    */
  897.             M_RET( I.AF.b.l & VF );
  898.             break;
  899.         case 0xe9: i8085_ICount -= 4;    /* PCHL */
  900.             I.PC.d = I.HL.w.l;
  901.             change_pc16(I.PC.d);
  902.             break;
  903.         case 0xea: i8085_ICount -= 10;    /* JPO    nnnn */
  904.             M_JMP( I.AF.b.l & VF );
  905.             break;
  906.         case 0xeb: i8085_ICount -= 4;    /* XCHG */
  907.             I.XX.d = I.DE.d;
  908.             I.DE.d = I.HL.d;
  909.             I.HL.d = I.XX.d;
  910.             break;
  911.         case 0xec: i8085_ICount -= 10;    /* CPO    nnnn */
  912.             M_CALL( I.AF.b.l & VF );
  913.             break;
  914.         case 0xed: i8085_ICount -= 4;    /* ???? */
  915.             illegal();
  916.             break;
  917.         case 0xee: i8085_ICount -= 7;    /* XRI    nn */
  918.             I.XX.b.l = ARG();
  919.             M_XRA(I.XX.b.l);
  920.             break;
  921.         case 0xef: i8085_ICount -= 11;    /* RST    5 */
  922.             M_RST(5);
  923.             break;
  924.  
  925.         case 0xf0: i8085_ICount -= 5;    /* RP    */
  926.             M_RET( !(I.AF.b.l&SF) );
  927.             break;
  928.         case 0xf1: i8085_ICount -= 10;    /* POP    A */
  929.             M_POP(AF);
  930.             break;
  931.         case 0xf2: i8085_ICount -= 10;    /* JP    nnnn */
  932.             M_JMP( !(I.AF.b.l & SF) );
  933.             break;
  934.         case 0xf3: i8085_ICount -= 4;    /* DI    */
  935.             /* remove interrupt enable */
  936.             I.IM &= ~IM_IEN;
  937.             break;
  938.         case 0xf4: i8085_ICount -= 10;    /* CP    nnnn */
  939.             M_CALL( !(I.AF.b.l & SF) );
  940.             break;
  941.         case 0xf5: i8085_ICount -= 11;    /* PUSH A */
  942.             M_PUSH(AF);
  943.             break;
  944.         case 0xf6: i8085_ICount -= 7;    /* ORI    nn */
  945.             I.XX.b.l = ARG();
  946.             M_ORA(I.XX.b.l);
  947.             break;
  948.         case 0xf7: i8085_ICount -= 11;    /* RST    6 */
  949.             M_RST(6);
  950.             break;
  951.  
  952.         case 0xf8: i8085_ICount -= 5;    /* RM    */
  953.             M_RET( I.AF.b.l & SF );
  954.             break;
  955.         case 0xf9: i8085_ICount -= 6;    /* SPHL */
  956.             I.SP.d = I.HL.d;
  957.             break;
  958.         case 0xfa: i8085_ICount -= 10;    /* JM    nnnn */
  959.             M_JMP( I.AF.b.l & SF );
  960.             break;
  961.         case 0xfb: i8085_ICount -= 4;    /* EI */
  962.             /* set interrupt enable */
  963.             I.IM |= IM_IEN;
  964.             /* remove serviced IRQ flag */
  965.             I.IREQ &= ~I.ISRV;
  966.             /* reset serviced IRQ */
  967.             I.ISRV = 0;
  968.             if( I.irq_state[0] != CLEAR_LINE )
  969.             {
  970.                 LOG(("i8085 EI sets INTR\n"));
  971.                 I.IREQ |= IM_INTR;
  972.                 I.INTR = I8085_INTR;
  973.             }
  974.             if( I.cputype )
  975.             {
  976.                 if( I.irq_state[1] != CLEAR_LINE )
  977.                 {
  978.                     LOG(("i8085 EI sets RST5.5\n"));
  979.                     I.IREQ |= IM_RST55;
  980.                 }
  981.                 if( I.irq_state[2] != CLEAR_LINE )
  982.                 {
  983.                     LOG(("i8085 EI sets RST6.5\n"));
  984.                     I.IREQ |= IM_RST65;
  985.                 }
  986.                 if( I.irq_state[3] != CLEAR_LINE )
  987.                 {
  988.                     LOG(("i8085 EI sets RST7.5\n"));
  989.                     I.IREQ |= IM_RST75;
  990.                 }
  991.                 /* find highest priority IREQ flag with
  992.                    IM enabled and schedule for execution */
  993.                 if( !(I.IM & IM_RST75) && (I.IREQ & IM_RST75) )
  994.                 {
  995.                     I.ISRV = IM_RST75;
  996.                     I.IRQ2 = ADDR_RST75;
  997.                 }
  998.                 else
  999.                 if( !(I.IM & IM_RST65) && (I.IREQ & IM_RST65) )
  1000.                 {
  1001.                     I.ISRV = IM_RST65;
  1002.                     I.IRQ2 = ADDR_RST65;
  1003.                 }
  1004.                 else
  1005.                 if( !(I.IM & IM_RST55) && (I.IREQ & IM_RST55) )
  1006.                 {
  1007.                     I.ISRV = IM_RST55;
  1008.                     I.IRQ2 = ADDR_RST55;
  1009.                 }
  1010.                 else
  1011.                 if( !(I.IM & IM_INTR) && (I.IREQ & IM_INTR) )
  1012.                 {
  1013.                     I.ISRV = IM_INTR;
  1014.                     I.IRQ2 = I.INTR;
  1015.                 }
  1016.             }
  1017.             else
  1018.             {
  1019.                 if( !(I.IM & IM_INTR) && (I.IREQ & IM_INTR) )
  1020.                 {
  1021.                     I.ISRV = IM_INTR;
  1022.                     I.IRQ2 = I.INTR;
  1023.                 }
  1024.             }
  1025.             break;
  1026.         case 0xfc: i8085_ICount -= 10;    /* CM    nnnn */
  1027.             M_CALL( I.AF.b.l & SF );
  1028.             break;
  1029.         case 0xfd: i8085_ICount -= 4;    /* ???? */
  1030.             illegal();
  1031.             break;
  1032.         case 0xfe: i8085_ICount -= 7;    /* CPI    nn */
  1033.             I.XX.b.l = ARG();
  1034.             M_CMP(I.XX.b.l);
  1035.             break;
  1036.         case 0xff: i8085_ICount -= 11;    /* RST    7 */
  1037.             M_RST(7);
  1038.             break;
  1039.     }
  1040. }
  1041.  
  1042. static void Interrupt(void)
  1043. {
  1044.  
  1045.     if( I.HALT )        /* if the CPU was halted */
  1046.     {
  1047.         I.PC.w.l++;     /* skip HALT instr */
  1048.         I.HALT = 0;
  1049.     }
  1050.     I.IM &= ~IM_IEN;        /* remove general interrupt enable bit */
  1051.  
  1052.     if( I.ISRV == IM_INTR )
  1053.     {
  1054.         LOG(("Interrupt get INTR vector\n"));
  1055.         I.IRQ1 = (I.irq_callback)(0);
  1056.     }
  1057.  
  1058.     if( I.cputype )
  1059.     {
  1060.         if( I.ISRV == IM_RST55 )
  1061.         {
  1062.             LOG(("Interrupt get RST5.5 vector\n"));
  1063.             I.IRQ1 = (I.irq_callback)(1);
  1064.         }
  1065.  
  1066.         if( I.ISRV == IM_RST65    )
  1067.         {
  1068.             LOG(("Interrupt get RST6.5 vector\n"));
  1069.             I.IRQ1 = (I.irq_callback)(2);
  1070.         }
  1071.  
  1072.         if( I.ISRV == IM_RST75 )
  1073.         {
  1074.             LOG(("Interrupt get RST7.5 vector\n"));
  1075.             I.IRQ1 = (I.irq_callback)(3);
  1076.         }
  1077.     }
  1078.  
  1079.     switch( I.IRQ1 & 0xff0000 )
  1080.     {
  1081.         case 0xcd0000:    /* CALL nnnn */
  1082.             i8085_ICount -= 7;
  1083.             M_PUSH(PC);
  1084.         case 0xc30000:    /* JMP    nnnn */
  1085.             i8085_ICount -= 10;
  1086.             I.PC.d = I.IRQ1 & 0xffff;
  1087.             change_pc16(I.PC.d);
  1088.             break;
  1089.         default:
  1090.             switch( I.IRQ1 )
  1091.             {
  1092.                 case I8085_TRAP:
  1093.                 case I8085_RST75:
  1094.                 case I8085_RST65:
  1095.                 case I8085_RST55:
  1096.                     M_PUSH(PC);
  1097.                     if (I.IRQ1 != I8085_RST75)
  1098.                         I.PC.d = I.IRQ1;
  1099.                     else
  1100.                         I.PC.d = 0x3c;
  1101.                     change_pc16(I.PC.d);
  1102.                     break;
  1103.                 default:
  1104.                     LOG(("i8085 take int $%02x\n", I.IRQ1));
  1105.                     execute_one(I.IRQ1 & 0xff);
  1106.             }
  1107.     }
  1108. }
  1109.  
  1110. int i8085_execute(int cycles)
  1111. {
  1112.  
  1113.     i8085_ICount = cycles;
  1114.     do
  1115.     {
  1116.         CALL_MAME_DEBUG;
  1117.         /* interrupts enabled or TRAP pending ? */
  1118.         if ( (I.IM & IM_IEN) || (I.IREQ & IM_TRAP) )
  1119.         {
  1120.             /* copy scheduled to executed interrupt request */
  1121.             I.IRQ1 = I.IRQ2;
  1122.             /* reset scheduled interrupt request */
  1123.             I.IRQ2 = 0;
  1124.             /* interrupt now ? */
  1125.             if (I.IRQ1) Interrupt();
  1126.         }
  1127.  
  1128.         /* here we go... */
  1129.         execute_one(ROP());
  1130.  
  1131.     } while (i8085_ICount > 0);
  1132.  
  1133.     return cycles - i8085_ICount;
  1134. }
  1135.  
  1136. /****************************************************************************
  1137.  * Initialise the various lookup tables used by the emulation code
  1138.  ****************************************************************************/
  1139. static void init_tables (void)
  1140. {
  1141.     UINT8 zs;
  1142.     int i, p;
  1143.     for (i = 0; i < 256; i++)
  1144.     {
  1145.         zs = 0;
  1146.         if (i==0) zs |= ZF;
  1147.         if (i&128) zs |= SF;
  1148.         p = 0;
  1149.         if (i&1) ++p;
  1150.         if (i&2) ++p;
  1151.         if (i&4) ++p;
  1152.         if (i&8) ++p;
  1153.         if (i&16) ++p;
  1154.         if (i&32) ++p;
  1155.         if (i&64) ++p;
  1156.         if (i&128) ++p;
  1157.         ZS[i] = zs;
  1158.         ZSP[i] = zs | ((p&1) ? 0 : VF);
  1159.     }
  1160. }
  1161.  
  1162. /****************************************************************************
  1163.  * Reset the 8085 emulation
  1164.  ****************************************************************************/
  1165. void i8085_reset(void *param)
  1166. {
  1167.     init_tables();
  1168.     memset(&I, 0, sizeof(i8085_Regs));
  1169.     I.cputype = 1;
  1170.     change_pc16(I.PC.d);
  1171. }
  1172.  
  1173. /****************************************************************************
  1174.  * Shut down the CPU emulation
  1175.  ****************************************************************************/
  1176. void i8085_exit(void)
  1177. {
  1178.     /* nothing to do */
  1179. }
  1180.  
  1181. /****************************************************************************
  1182.  * Get the current 8085 context
  1183.  ****************************************************************************/
  1184. unsigned i8085_get_context(void *dst)
  1185. {
  1186.     if( dst )
  1187.         *(i8085_Regs*)dst = I;
  1188.     return sizeof(i8085_Regs);
  1189. }
  1190.  
  1191. /****************************************************************************
  1192.  * Set the current 8085 context
  1193.  ****************************************************************************/
  1194. void i8085_set_context(void *src)
  1195. {
  1196.     if( src )
  1197.     {
  1198.         I = *(i8085_Regs*)src;
  1199.         change_pc(I.PC.d);
  1200.     }
  1201. }
  1202.  
  1203. /****************************************************************************
  1204.  * Get the current 8085 PC
  1205.  ****************************************************************************/
  1206. unsigned i8085_get_pc(void)
  1207. {
  1208.     return I.PC.d;
  1209. }
  1210.  
  1211. /****************************************************************************
  1212.  * Set the current 8085 PC
  1213.  ****************************************************************************/
  1214. void i8085_set_pc(unsigned val)
  1215. {
  1216.     I.PC.w.l = val;
  1217.     change_pc(I.PC.d);
  1218. }
  1219.  
  1220. /****************************************************************************
  1221.  * Get the current 8085 SP
  1222.  ****************************************************************************/
  1223. unsigned i8085_get_sp(void)
  1224. {
  1225.     return I.SP.d;
  1226. }
  1227.  
  1228. /****************************************************************************
  1229.  * Set the current 8085 SP
  1230.  ****************************************************************************/
  1231. void i8085_set_sp(unsigned val)
  1232. {
  1233.     I.SP.w.l = val;
  1234. }
  1235.  
  1236. /****************************************************************************
  1237.  * Get a specific register
  1238.  ****************************************************************************/
  1239. unsigned i8085_get_reg(int regnum)
  1240. {
  1241.     switch( regnum )
  1242.     {
  1243.         case I8085_PC: return I.PC.w.l;
  1244.         case I8085_SP: return I.SP.w.l;
  1245.         case I8085_AF: return I.AF.w.l;
  1246.         case I8085_BC: return I.BC.w.l;
  1247.         case I8085_DE: return I.DE.w.l;
  1248.         case I8085_HL: return I.HL.w.l;
  1249.         case I8085_IM: return I.IM;
  1250.         case I8085_HALT: return I.HALT;
  1251.         case I8085_IREQ: return I.IREQ;
  1252.         case I8085_ISRV: return I.ISRV;
  1253.         case I8085_VECTOR: return I.INTR;
  1254.         case I8085_TRAP_STATE: return I.nmi_state;
  1255.         case I8085_INTR_STATE: return I.irq_state[I8085_INTR_LINE];
  1256.         case I8085_RST55_STATE: return I.irq_state[I8085_RST55_LINE];
  1257.         case I8085_RST65_STATE: return I.irq_state[I8085_RST65_LINE];
  1258.         case I8085_RST75_STATE: return I.irq_state[I8085_RST75_LINE];
  1259.         case REG_PREVIOUSPC: return 0; /* previous pc not supported */
  1260.         default:
  1261.             if( regnum <= REG_SP_CONTENTS )
  1262.             {
  1263.                 unsigned offset = I.SP.w.l + 2 * (REG_SP_CONTENTS - regnum);
  1264.                 if( offset < 0xffff )
  1265.                     return RM( offset ) + ( RM( offset+1 ) << 8 );
  1266.             }
  1267.     }
  1268.     return 0;
  1269. }
  1270.  
  1271. /****************************************************************************
  1272.  * Set a specific register
  1273.  ****************************************************************************/
  1274. void i8085_set_reg(int regnum, unsigned val)
  1275. {
  1276.     switch( regnum )
  1277.     {
  1278.         case I8085_PC: I.PC.w.l = val; break;
  1279.         case I8085_SP: I.SP.w.l = val; break;
  1280.         case I8085_AF: I.AF.w.l = val; break;
  1281.         case I8085_BC: I.BC.w.l = val; break;
  1282.         case I8085_DE: I.DE.w.l = val; break;
  1283.         case I8085_HL: I.HL.w.l = val; break;
  1284.         case I8085_IM: I.IM = val; break;
  1285.         case I8085_HALT: I.HALT = val; break;
  1286.         case I8085_IREQ: I.IREQ = val; break;
  1287.         case I8085_ISRV: I.ISRV = val; break;
  1288.         case I8085_VECTOR: I.INTR = val; break;
  1289.         case I8085_TRAP_STATE: I.nmi_state = val; break;
  1290.         case I8085_INTR_STATE: I.irq_state[I8085_INTR_LINE] = val; break;
  1291.         case I8085_RST55_STATE: I.irq_state[I8085_RST55_LINE] = val; break;
  1292.         case I8085_RST65_STATE: I.irq_state[I8085_RST65_LINE] = val; break;
  1293.         case I8085_RST75_STATE: I.irq_state[I8085_RST75_LINE] = val; break;
  1294.         default:
  1295.             if( regnum <= REG_SP_CONTENTS )
  1296.             {
  1297.                 unsigned offset = I.SP.w.l + 2 * (REG_SP_CONTENTS - regnum);
  1298.                 if( offset < 0xffff )
  1299.                 {
  1300.                     WM( offset, val&0xff );
  1301.                     WM( offset+1, (val>>8)&0xff );
  1302.                 }
  1303.             }
  1304.     }
  1305. }
  1306.  
  1307. /****************************************************************************/
  1308. /* Set the 8085 SID input signal state                                      */
  1309. /****************************************************************************/
  1310. void i8085_set_SID(int state)
  1311. {
  1312.     LOG(("i8085: SID %d\n", state));
  1313.     if (state)
  1314.         I.IM |= IM_SID;
  1315.     else
  1316.         I.IM &= ~IM_SID;
  1317. }
  1318.  
  1319. /****************************************************************************/
  1320. /* Set a callback to be called at SOD output change                         */
  1321. /****************************************************************************/
  1322. void i8085_set_sod_callback(void (*callback)(int state))
  1323. {
  1324.     I.sod_callback = callback;
  1325. }
  1326.  
  1327. /****************************************************************************/
  1328. /* Set TRAP signal state                                                    */
  1329. /****************************************************************************/
  1330. void i8085_set_TRAP(int state)
  1331. {
  1332.     LOG(("i8085: TRAP %d\n", state));
  1333.     if (state)
  1334.     {
  1335.         I.IREQ |= IM_TRAP;
  1336.         if( I.ISRV & IM_TRAP ) return;    /* already servicing TRAP ? */
  1337.         I.ISRV = IM_TRAP;                /* service TRAP */
  1338.         I.IRQ2 = ADDR_TRAP;
  1339.     }
  1340.     else
  1341.     {
  1342.         I.IREQ &= ~IM_TRAP;             /* remove request for TRAP */
  1343.     }
  1344. }
  1345.  
  1346. /****************************************************************************/
  1347. /* Set RST7.5 signal state                                                  */
  1348. /****************************************************************************/
  1349. void i8085_set_RST75(int state)
  1350. {
  1351.     LOG(("i8085: RST7.5 %d\n", state));
  1352.     if( state )
  1353.     {
  1354.  
  1355.         I.IREQ |= IM_RST75;             /* request RST7.5 */
  1356.         if( I.IM & IM_RST75 ) return;    /* if masked, ignore it for now */
  1357.         if( !I.ISRV )                    /* if no higher priority IREQ is serviced */
  1358.         {
  1359.             I.ISRV = IM_RST75;            /* service RST7.5 */
  1360.             I.IRQ2 = ADDR_RST75;
  1361.         }
  1362.     }
  1363.     /* RST7.5 is reset only by SIM or end of service routine ! */
  1364. }
  1365.  
  1366. /****************************************************************************/
  1367. /* Set RST6.5 signal state                                                  */
  1368. /****************************************************************************/
  1369. void i8085_set_RST65(int state)
  1370. {
  1371.     LOG(("i8085: RST6.5 %d\n", state));
  1372.     if( state )
  1373.     {
  1374.         I.IREQ |= IM_RST65;             /* request RST6.5 */
  1375.         if( I.IM & IM_RST65 ) return;    /* if masked, ignore it for now */
  1376.         if( !I.ISRV )                    /* if no higher priority IREQ is serviced */
  1377.         {
  1378.             I.ISRV = IM_RST65;            /* service RST6.5 */
  1379.             I.IRQ2 = ADDR_RST65;
  1380.         }
  1381.     }
  1382.     else
  1383.     {
  1384.         I.IREQ &= ~IM_RST65;            /* remove request for RST6.5 */
  1385.     }
  1386. }
  1387.  
  1388. /****************************************************************************/
  1389. /* Set RST5.5 signal state                                                  */
  1390. /****************************************************************************/
  1391. void i8085_set_RST55(int state)
  1392. {
  1393.     LOG(("i8085: RST5.5 %d\n", state));
  1394.     if( state )
  1395.     {
  1396.         I.IREQ |= IM_RST55;             /* request RST5.5 */
  1397.         if( I.IM & IM_RST55 ) return;    /* if masked, ignore it for now */
  1398.         if( !I.ISRV )                    /* if no higher priority IREQ is serviced */
  1399.         {
  1400.             I.ISRV = IM_RST55;            /* service RST5.5 */
  1401.             I.IRQ2 = ADDR_RST55;
  1402.         }
  1403.     }
  1404.     else
  1405.     {
  1406.         I.IREQ &= ~IM_RST55;            /* remove request for RST5.5 */
  1407.     }
  1408. }
  1409.  
  1410. /****************************************************************************/
  1411. /* Set INTR signal                                                          */
  1412. /****************************************************************************/
  1413. void i8085_set_INTR(int state)
  1414. {
  1415.     LOG(("i8085: INTR %d\n", state));
  1416.     if( state )
  1417.     {
  1418.         I.IREQ |= IM_INTR;                /* request INTR */
  1419.         I.INTR = state;
  1420.         if( I.IM & IM_INTR ) return;    /* if masked, ignore it for now */
  1421.         if( !I.ISRV )                    /* if no higher priority IREQ is serviced */
  1422.         {
  1423.             I.ISRV = IM_INTR;            /* service INTR */
  1424.             I.IRQ2 = I.INTR;
  1425.         }
  1426.     }
  1427.     else
  1428.     {
  1429.         I.IREQ &= ~IM_INTR;             /* remove request for INTR */
  1430.     }
  1431. }
  1432.  
  1433. void i8085_set_nmi_line(int state)
  1434. {
  1435.     I.nmi_state = state;
  1436.     if( state != CLEAR_LINE )
  1437.         i8085_set_TRAP(1);
  1438. }
  1439.  
  1440. void i8085_set_irq_line(int irqline, int state)
  1441. {
  1442.     I.irq_state[irqline] = state;
  1443.     if (state == CLEAR_LINE)
  1444.     {
  1445.         if( !(I.IM & IM_IEN) )
  1446.         {
  1447.             switch (irqline)
  1448.             {
  1449.                 case I8085_INTR_LINE: i8085_set_INTR(0); break;
  1450.                 case I8085_RST55_LINE: i8085_set_RST55(0); break;
  1451.                 case I8085_RST65_LINE: i8085_set_RST65(0); break;
  1452.                 case I8085_RST75_LINE: i8085_set_RST75(0); break;
  1453.             }
  1454.         }
  1455.     }
  1456.     else
  1457.     {
  1458.         if( I.IM & IM_IEN )
  1459.         {
  1460.             switch( irqline )
  1461.             {
  1462.                 case I8085_INTR_LINE: i8085_set_INTR(1); break;
  1463.                 case I8085_RST55_LINE: i8085_set_RST55(1); break;
  1464.                 case I8085_RST65_LINE: i8085_set_RST65(1); break;
  1465.                 case I8085_RST75_LINE: i8085_set_RST75(1); break;
  1466.             }
  1467.         }
  1468.     }
  1469. }
  1470.  
  1471. void i8085_set_irq_callback(int (*callback)(int))
  1472. {
  1473.     I.irq_callback = callback;
  1474. }
  1475.  
  1476. void i8085_state_save(void *file)
  1477. {
  1478.     int cpu = cpu_getactivecpu();
  1479.     state_save_UINT16(file, "i8085", cpu, "AF", &I.AF.w.l, 1);
  1480.     state_save_UINT16(file, "i8085", cpu, "BC", &I.BC.w.l, 1);
  1481.     state_save_UINT16(file, "i8085", cpu, "DE", &I.DE.w.l, 1);
  1482.     state_save_UINT16(file, "i8085", cpu, "HL", &I.HL.w.l, 1);
  1483.     state_save_UINT16(file, "i8085", cpu, "SP", &I.SP.w.l, 1);
  1484.     state_save_UINT16(file, "i8085", cpu, "PC", &I.PC.w.l, 1);
  1485.     state_save_UINT8(file, "i8085", cpu, "HALT", &I.HALT, 1);
  1486.     state_save_UINT8(file, "i8085", cpu, "IM", &I.IM, 1);
  1487.     state_save_UINT8(file, "i8085", cpu, "IREQ", &I.IREQ, 1);
  1488.     state_save_UINT8(file, "i8085", cpu, "ISRV", &I.ISRV, 1);
  1489.     state_save_UINT32(file, "i8085", cpu, "INTR", &I.INTR, 1);
  1490.     state_save_UINT32(file, "i8085", cpu, "IRQ2", &I.IRQ2, 1);
  1491.     state_save_UINT32(file, "i8085", cpu, "IRQ1", &I.IRQ1, 1);
  1492.     state_save_INT8(file, "i8085", cpu, "NMI_STATE", &I.nmi_state, 1);
  1493.     state_save_INT8(file, "i8085", cpu, "IRQ_STATE", I.irq_state, 4);
  1494. }
  1495.  
  1496. void i8085_state_load(void *file)
  1497. {
  1498.     int cpu = cpu_getactivecpu();
  1499.     state_load_UINT16(file, "i8085", cpu, "AF", &I.AF.w.l, 1);
  1500.     state_load_UINT16(file, "i8085", cpu, "BC", &I.BC.w.l, 1);
  1501.     state_load_UINT16(file, "i8085", cpu, "DE", &I.DE.w.l, 1);
  1502.     state_load_UINT16(file, "i8085", cpu, "HL", &I.HL.w.l, 1);
  1503.     state_load_UINT16(file, "i8085", cpu, "SP", &I.SP.w.l, 1);
  1504.     state_load_UINT16(file, "i8085", cpu, "PC", &I.PC.w.l, 1);
  1505.     state_load_UINT8(file, "i8085", cpu, "HALT", &I.HALT, 1);
  1506.     state_load_UINT8(file, "i8085", cpu, "IM", &I.IM, 1);
  1507.     state_load_UINT8(file, "i8085", cpu, "IREQ", &I.IREQ, 1);
  1508.     state_load_UINT8(file, "i8085", cpu, "ISRV", &I.ISRV, 1);
  1509.     state_load_UINT32(file, "i8085", cpu, "INTR", &I.INTR, 1);
  1510.     state_load_UINT32(file, "i8085", cpu, "IRQ2", &I.IRQ2, 1);
  1511.     state_load_UINT32(file, "i8085", cpu, "IRQ1", &I.IRQ1, 1);
  1512.     state_load_INT8(file, "i8085", cpu, "NMI_STATE", &I.nmi_state, 1);
  1513.     state_load_INT8(file, "i8085", cpu, "IRQ_STATE", I.irq_state, 4);
  1514. }
  1515.  
  1516. /****************************************************************************
  1517.  * Return a formatted string for a register
  1518.  ****************************************************************************/
  1519. const char *i8085_info(void *context, int regnum)
  1520. {
  1521.     static char buffer[16][47+1];
  1522.     static int which = 0;
  1523.     i8085_Regs *r = context;
  1524.  
  1525.     which = ++which % 16;
  1526.     buffer[which][0] = '\0';
  1527.     if( !context )
  1528.         r = &I;
  1529.  
  1530.     switch( regnum )
  1531.     {
  1532.         case CPU_INFO_REG+I8085_AF: sprintf(buffer[which], "AF:%04X", r->AF.w.l); break;
  1533.         case CPU_INFO_REG+I8085_BC: sprintf(buffer[which], "BC:%04X", r->BC.w.l); break;
  1534.         case CPU_INFO_REG+I8085_DE: sprintf(buffer[which], "DE:%04X", r->DE.w.l); break;
  1535.         case CPU_INFO_REG+I8085_HL: sprintf(buffer[which], "HL:%04X", r->HL.w.l); break;
  1536.         case CPU_INFO_REG+I8085_SP: sprintf(buffer[which], "SP:%04X", r->SP.w.l); break;
  1537.         case CPU_INFO_REG+I8085_PC: sprintf(buffer[which], "PC:%04X", r->PC.w.l); break;
  1538.         case CPU_INFO_REG+I8085_IM: sprintf(buffer[which], "IM:%02X", r->IM); break;
  1539.         case CPU_INFO_REG+I8085_HALT: sprintf(buffer[which], "HALT:%d", r->HALT); break;
  1540.         case CPU_INFO_REG+I8085_IREQ: sprintf(buffer[which], "IREQ:%02X", I.IREQ); break;
  1541.         case CPU_INFO_REG+I8085_ISRV: sprintf(buffer[which], "ISRV:%02X", I.ISRV); break;
  1542.         case CPU_INFO_REG+I8085_VECTOR: sprintf(buffer[which], "VEC:%02X", I.INTR); break;
  1543.         case CPU_INFO_REG+I8085_TRAP_STATE: sprintf(buffer[which], "TRAP:%X", I.nmi_state); break;
  1544.         case CPU_INFO_REG+I8085_INTR_STATE: sprintf(buffer[which], "INTR:%X", I.irq_state[I8085_INTR_LINE]); break;
  1545.         case CPU_INFO_REG+I8085_RST55_STATE: sprintf(buffer[which], "RST55:%X", I.irq_state[I8085_RST55_LINE]); break;
  1546.         case CPU_INFO_REG+I8085_RST65_STATE: sprintf(buffer[which], "RST65:%X", I.irq_state[I8085_RST65_LINE]); break;
  1547.         case CPU_INFO_REG+I8085_RST75_STATE: sprintf(buffer[which], "RST75:%X", I.irq_state[I8085_RST75_LINE]); break;
  1548.         case CPU_INFO_FLAGS:
  1549.             sprintf(buffer[which], "%c%c%c%c%c%c%c%c",
  1550.                 r->AF.b.l & 0x80 ? 'S':'.',
  1551.                 r->AF.b.l & 0x40 ? 'Z':'.',
  1552.                 r->AF.b.l & 0x20 ? '?':'.',
  1553.                 r->AF.b.l & 0x10 ? 'H':'.',
  1554.                 r->AF.b.l & 0x08 ? '?':'.',
  1555.                 r->AF.b.l & 0x04 ? 'P':'.',
  1556.                 r->AF.b.l & 0x02 ? 'N':'.',
  1557.                 r->AF.b.l & 0x01 ? 'C':'.');
  1558.             break;
  1559.         case CPU_INFO_NAME: return "8085A";
  1560.         case CPU_INFO_FAMILY: return "Intel 8080";
  1561.         case CPU_INFO_VERSION: return "1.1";
  1562.         case CPU_INFO_FILE: return __FILE__;
  1563.         case CPU_INFO_CREDITS: return "Copyright (c) 1999 Juergen Buchmueller, all rights reserved.";
  1564.         case CPU_INFO_REG_LAYOUT: return (const char *)i8085_reg_layout;
  1565.         case CPU_INFO_WIN_LAYOUT: return (const char *)i8085_win_layout;
  1566.     }
  1567.     return buffer[which];
  1568. }
  1569.  
  1570. unsigned i8085_dasm(char *buffer, unsigned pc)
  1571. {
  1572. #ifdef MAME_DEBUG
  1573.     return Dasm8085(buffer,pc);
  1574. #else
  1575.     sprintf( buffer, "$%02X", cpu_readop(pc) );
  1576.     return 1;
  1577. #endif
  1578. }
  1579.  
  1580.  
  1581. /**************************************************************************
  1582.  * 8080 section
  1583.  **************************************************************************/
  1584. #if (HAS_8080)
  1585. /* Layout of the registers in the debugger */
  1586. static UINT8 i8080_reg_layout[] = {
  1587.     I8080_AF, I8080_BC, I8080_DE, I8080_HL, I8080_SP, I8080_PC, -1,
  1588.     I8080_HALT, I8080_IREQ, I8080_ISRV, I8080_VECTOR, I8080_TRAP_STATE, I8080_INTR_STATE,
  1589.     0 };
  1590.  
  1591. /* Layout of the debugger windows x,y,w,h */
  1592. static UINT8 i8080_win_layout[] = {
  1593.     25, 0,55, 2,    /* register window (top, right rows) */
  1594.      0, 0,24,22,    /* disassembler window (left colums) */
  1595.     25, 3,55,10,    /* memory #1 window (right, upper middle) */
  1596.     25,14,55, 8,    /* memory #2 window (right, lower middle) */
  1597.      0,23,80, 1,    /* command line window (bottom rows) */
  1598. };
  1599.  
  1600.  
  1601. void i8080_reset(void *param)
  1602. {
  1603.     i8085_reset(param);
  1604.     I.cputype = 0;
  1605. }
  1606. void i8080_exit(void) { i8085_exit(); }
  1607. int i8080_execute(int cycles) { return i8085_execute(cycles); }
  1608. unsigned i8080_get_context(void *dst) { return i8085_get_context(dst); }
  1609. void i8080_set_context(void *src) { i8085_set_context(src); }
  1610. unsigned i8080_get_pc(void) { return i8085_get_pc(); }
  1611. void i8080_set_pc(unsigned val) { i8085_set_pc(val); }
  1612. unsigned i8080_get_sp(void) { return i8085_get_sp(); }
  1613. void i8080_set_sp(unsigned val) { i8085_set_sp(val); }
  1614. unsigned i8080_get_reg(int regnum) { return i8085_get_reg(regnum); }
  1615. void i8080_set_reg(int regnum, unsigned val)  { i8085_set_reg(regnum,val); }
  1616. void i8080_set_nmi_line(int state)    { i8085_set_nmi_line(state); }
  1617. void i8080_set_irq_line(int irqline, int state)
  1618. {
  1619.     I.irq_state[irqline] = state;
  1620.     if (state == CLEAR_LINE)
  1621.     {
  1622.         if (!(I.IM & IM_IEN))
  1623.             i8085_set_INTR(0);
  1624.     }
  1625.     else
  1626.     {
  1627.         if (I.IM & IM_IEN)
  1628.             i8085_set_INTR(1);
  1629.     }
  1630. }
  1631. void i8080_set_irq_callback(int (*callback)(int irqline)) { i8085_set_irq_callback(callback); }
  1632.  
  1633. void i8080_state_save(void *file)
  1634. {
  1635.     int cpu = cpu_getactivecpu();
  1636.     state_save_UINT16(file, "i8080", cpu, "AF", &I.AF.w.l, 1);
  1637.     state_save_UINT16(file, "i8080", cpu, "BC", &I.BC.w.l, 1);
  1638.     state_save_UINT16(file, "i8080", cpu, "DE", &I.DE.w.l, 1);
  1639.     state_save_UINT16(file, "i8080", cpu, "HL", &I.HL.w.l, 1);
  1640.     state_save_UINT16(file, "i8080", cpu, "SP", &I.SP.w.l, 1);
  1641.     state_save_UINT16(file, "i8080", cpu, "PC", &I.PC.w.l, 1);
  1642.     state_save_UINT8(file, "i8080", cpu, "HALT", &I.HALT, 1);
  1643.     state_save_UINT8(file, "i8080", cpu, "IREQ", &I.IREQ, 1);
  1644.     state_save_UINT8(file, "i8080", cpu, "ISRV", &I.ISRV, 1);
  1645.     state_save_UINT32(file, "i8080", cpu, "INTR", &I.INTR, 1);
  1646.     state_save_UINT32(file, "i8080", cpu, "IRQ2", &I.IRQ2, 1);
  1647.     state_save_UINT32(file, "i8080", cpu, "IRQ1", &I.IRQ1, 1);
  1648.     state_save_INT8(file, "i8080", cpu, "NMI_STATE", &I.nmi_state, 1);
  1649.     state_save_INT8(file, "i8080", cpu, "IRQ_STATE", I.irq_state, 1);
  1650. }
  1651.  
  1652. void i8080_state_load(void *file)
  1653. {
  1654.     int cpu = cpu_getactivecpu();
  1655.     state_load_UINT16(file, "i8080", cpu, "AF", &I.AF.w.l, 1);
  1656.     state_load_UINT16(file, "i8080", cpu, "BC", &I.BC.w.l, 1);
  1657.     state_load_UINT16(file, "i8080", cpu, "DE", &I.DE.w.l, 1);
  1658.     state_load_UINT16(file, "i8080", cpu, "HL", &I.HL.w.l, 1);
  1659.     state_load_UINT16(file, "i8080", cpu, "SP", &I.SP.w.l, 1);
  1660.     state_load_UINT16(file, "i8080", cpu, "PC", &I.PC.w.l, 1);
  1661.     state_load_UINT8(file, "i8080", cpu, "HALT", &I.HALT, 1);
  1662.     state_load_UINT8(file, "i8080", cpu, "IREQ", &I.IREQ, 1);
  1663.     state_load_UINT8(file, "i8080", cpu, "ISRV", &I.ISRV, 1);
  1664.     state_load_UINT32(file, "i8080", cpu, "INTR", &I.INTR, 1);
  1665.     state_load_UINT32(file, "i8080", cpu, "IRQ2", &I.IRQ2, 1);
  1666.     state_load_UINT32(file, "i8080", cpu, "IRQ1", &I.IRQ1, 1);
  1667.     state_load_INT8(file, "i8080", cpu, "NMI_STATE", &I.nmi_state, 1);
  1668.     state_load_INT8(file, "i8080", cpu, "IRQ_STATE", I.irq_state, 1);
  1669. }
  1670.  
  1671. const char *i8080_info(void *context, int regnum)
  1672. {
  1673.     switch( regnum )
  1674.     {
  1675.         case CPU_INFO_NAME: return "8080";
  1676.         case CPU_INFO_VERSION: return "1.0";
  1677.         case CPU_INFO_REG_LAYOUT: return (const char *)i8080_reg_layout;
  1678.         case CPU_INFO_WIN_LAYOUT: return (const char *)i8080_win_layout;
  1679.     }
  1680.     return i8085_info(context,regnum);
  1681. }
  1682.  
  1683. unsigned i8080_dasm(char *buffer, unsigned pc)
  1684. {
  1685. #ifdef MAME_DEBUG
  1686.     return Dasm8085(buffer,pc);
  1687. #else
  1688.     sprintf( buffer, "$%02X", cpu_readop(pc) );
  1689.     return 1;
  1690. #endif
  1691. }
  1692. #endif
  1693.